home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / utilities / cli / msplit.lha / MSplit.c next >
Encoding:
C/C++ Source or Header  |  1995-01-31  |  10.0 KB  |  467 lines
  1. #include <exec/types.h>            /* BOOL etc. Type-Definitions     */
  2. #include <dos/dos.h>               /* Definition of RETURN_FAIL etc. */
  3.  
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <string.h>
  7. #include <ctype.h>
  8.  
  9. /* Konstanten -------------------------------------------------------------------------- */
  10.  
  11. #define MISSING_FILENAME    1
  12. #define SIZE_NOT_LEGAL        2
  13. #define NUMBER_NOT_LEGAL    3
  14. #define WRONG_PARAMETERS    4
  15. #define MISSING_WILDCARD  5
  16. #define FROM_NOT_LEGAL        6
  17. #define FROM_TOO_LOW            7
  18. /* --------------------- */
  19. #define PARSE_ERROR       7
  20. /* --------------------- */
  21. #define FILE_EXISTS             20
  22. #define NO_MEMORY        21
  23. #define MISSING_FILE         22
  24. #define CANNOT_OPEN_FILE 23
  25.  
  26. /* Funktions-Protos -------------------------------------------------------------------- */
  27.  
  28. void PrintError(int );
  29. void WrongArgs(char *);
  30. char * MakeFileName(int);
  31. char * Uppercase(char *);
  32. BOOL   fileexist(char *);
  33.  
  34.  
  35. /* Globale Variablen ------------------------------------------------------------------- */
  36.  
  37. BOOL force = FALSE;
  38. BOOL quiet = FALSE;
  39. BOOL doublenull = FALSE;
  40. int  from = 0;
  41. int  number = 0;
  42. int  size = 0;
  43. char * filename = NULL;
  44. char * basename = NULL;
  45. const char * wildcard = "*";
  46.  
  47. /* main -------------------------------------------------------------------------------- */
  48.  
  49. int main(int ArgC, char * ArgV[])
  50. {
  51.     int    arg = 1;                                                /* Aktuelle Argumentnummer */
  52.     int    filenr = 0;                    /* Aktuelle Nummer des bearbeiteten Files */
  53.     int    zeichen;                       /* Zeichen-Transfer-Puffer */
  54.     int    WCpos = 0;                     /* Dient zum finden des Wildcards */
  55.     int    baselen = 0;                   /* Länge des Basenames */
  56.     int    filesize = 0;                  /* Größe des Trennfiles */    
  57.     int    lastsize = 0;                  /* Größe des letzten erzeugten Files */
  58.     int    portion = 0;                   /* Größe der einzelnen Files */
  59.     int    charno = 0;                    /* Nummer des kopierten Zeichens */
  60.     BOOL   ready = FALSE;                 /* Schleifenabbruchs-Boolean */
  61.     FILE * Outfp = NULL;                  /* Output-FilePointer */
  62.     FILE * Infp  = NULL;                  /* Input-FilePointer */
  63.     char * actualfilename = NULL;         /* Name des aktuellen Files */
  64.  
  65.     /* ------------------------ Parsing ------------------------- */
  66. /*fs*/
  67.     if(1 == ArgC)                        /* keine Parameter ist unzulässig */
  68.     {
  69.         PrintError(MISSING_FILENAME);
  70.         WrongArgs(ArgV[0]);
  71.     }
  72.     /* FileName-Parameter */
  73.     filename = ArgV[arg];
  74.     arg++;
  75.     /* FROM-Parameter */
  76.     if(arg+2 <= ArgC && 0 == strcmp("FROM", Uppercase(ArgV[arg]) ))
  77.     {
  78.         if(!isdigit(ArgV[arg+1][0]) ) 
  79.         {
  80.             PrintError(FROM_NOT_LEGAL);
  81.             WrongArgs(ArgV[0]);
  82.         }
  83.         from = atoi(ArgV[++arg]);
  84.         if(0 > from)
  85.         {
  86.             PrintError(FROM_TOO_LOW);
  87.             WrongArgs(ArgV[0]);
  88.         }
  89.         arg++;        
  90.     }
  91.     /* INTO-Parameter */
  92.     if(arg+2 <= ArgC && 0 == strcmp("INTO", Uppercase(ArgV[arg]) ))
  93.     {
  94.         basename = ArgV[++arg];
  95.         baselen = strlen(basename);
  96.         /* WildCard finden, Stelle in WCpos */
  97.         for(WCpos = 0; WCpos <=baselen; WCpos++)
  98.         {
  99.             if(wildcard[0] == basename[WCpos]) break;
  100.         }
  101.         if(WCpos > baselen)
  102.         {
  103.             PrintError(MISSING_WILDCARD);
  104.             WrongArgs(ArgV[0]);
  105.         }
  106.         arg++;
  107.     }
  108.     /* SIZE-Parameter */
  109.     if(arg+2 <= ArgC && 0 == strcmp("SIZE", Uppercase(ArgV[arg]) ))
  110.     {
  111.         if(!isdigit(ArgV[arg+1][0]) )
  112.         {
  113.             PrintError(SIZE_NOT_LEGAL);
  114.             WrongArgs(ArgV[0]);
  115.         }
  116.         size = atoi(ArgV[++arg]);
  117.         if(0 >= size)
  118.         {
  119.             PrintError(SIZE_NOT_LEGAL);
  120.             WrongArgs(ArgV[0]);
  121.         }
  122.         arg++;
  123.     } 
  124.     
  125.     /* PARTS-Parameter */
  126.     if(arg+2 <= ArgC && 0 == strcmp("PARTS", Uppercase(ArgV[arg]) ))
  127.     {
  128.         if(!isdigit(ArgV[arg+1][0]) )
  129.         {
  130.             PrintError(NUMBER_NOT_LEGAL);
  131.             WrongArgs(ArgV[0]);
  132.         }
  133.         number = atoi(ArgV[++arg]);
  134.         if(0 >= number)
  135.         {
  136.             PrintError(NUMBER_NOT_LEGAL);
  137.             WrongArgs(ArgV[0]);
  138.         }
  139.         arg++;
  140.     } 
  141.     while(!ready && arg+1 <= ArgC)          /* Abfrage der Booleans */
  142.     {
  143.         /* NULL-Parameter */
  144.         if(arg+1 <= ArgC && 0 == strcmp("NULL", Uppercase(ArgV[arg]) ))
  145.         {
  146.             doublenull = TRUE;
  147.             arg++;
  148.         }
  149.         /* QUIET-Parameter */
  150.         else if(arg+1 <= ArgC && 0 == strcmp("QUIET", Uppercase(ArgV[arg]) ))
  151.         {
  152.             quiet = TRUE;
  153.             arg++;
  154.         }
  155.         /* FORCE-Parameter */
  156.         else if(arg+1 <= ArgC && 0 == strcmp("FORCE", Uppercase(ArgV[arg]) ))
  157.         {
  158.             force = TRUE;
  159.             arg++;
  160.         }
  161.         /* Müll-Parameter führt zum Ende */
  162.         else 
  163.         {
  164.             PrintError(WRONG_PARAMETERS);
  165.             ready = TRUE;
  166.         }
  167.     }
  168.     if(arg != ArgC) WrongArgs(ArgV[0]);                   /* mind. ein  Parameter ungültig */
  169.   if(0 == size && 0 == number) number = 2;
  170.   if(NULL == basename)
  171.   {
  172.       basename = (char *) malloc(strlen(filename)+2);
  173.       sprintf(basename, "%s*",filename);
  174.   }
  175. /* --------------------------------------------------------------------------------------- */
  176. /*fe*/
  177.  
  178.  
  179.     if(!quiet) printf("\n  MSplit V1.1 by Harald Löffler\n\n");
  180.  
  181.     if(!fileexist(filename))
  182.     {
  183.         if(!quiet) PrintError(MISSING_FILE);
  184.         exit(RETURN_WARN);
  185.     }
  186.  
  187. /* Größe des zu trennenden Files feststellen */
  188.     Infp = fopen(filename, "r");
  189.   if(!Infp)
  190.   {
  191.       PrintError(CANNOT_OPEN_FILE);
  192.       exit(RETURN_ERROR);
  193.   }
  194.     filesize = 0;
  195.     while(EOF != (zeichen = getc(Infp)))
  196.     {
  197.         filesize++;
  198.     }
  199.     fclose(Infp);
  200. /* ----------------------------------------- */
  201.  
  202.     if(size != 0 && number == 0)
  203.     {
  204.         number = filesize/size;
  205.         if(0 != filesize % size)
  206.         {
  207.             number++;
  208.             lastsize = filesize - (number - 1) * size;
  209.         }
  210.         else {lastsize = size;}
  211.     }
  212.     else if(size == 0 && number != 0)
  213.     {
  214.         size = filesize/number;
  215.         if(0 != (filesize % number))
  216.         {
  217.             lastsize = size + filesize - number * size;
  218.             if(lastsize>size && 0 != filesize - (number - 1) * (size + 1))
  219.             {
  220.                 size++;
  221.                 lastsize = filesize - (number - 1) * size;
  222.             }
  223.         }
  224.         else {lastsize = size;}
  225.     }
  226.     else if(size != 0 && number != 0)
  227.     {
  228.         if(filesize < number * size)
  229.         {
  230.             number = filesize/size;
  231.             if(0 != filesize % size)
  232.             {
  233.                 number++;
  234.                 lastsize = filesize - (number-1) * size;
  235.             }
  236.             else {lastsize = size;}            
  237.         }
  238.         else
  239.         {
  240.             lastsize = filesize  - (number - 1) * size;
  241.         }
  242.     }
  243.  
  244.     Infp = fopen(filename, "r");
  245.     if(!Infp)
  246.     {
  247.         PrintError(CANNOT_OPEN_FILE);
  248.         exit(RETURN_ERROR);
  249.     }
  250.  
  251.     filenr = from;
  252.     do
  253.     {
  254.         actualfilename = MakeFileName(filenr);
  255.         printf("Part %i -> %s | ", filenr, actualfilename);
  256.  
  257.         if(filenr == number-1+from)
  258.         {
  259.             portion = lastsize;
  260.         }
  261.         else
  262.         {
  263.             portion = size;
  264.         }
  265.  
  266. /* Splitting in ein neues File mit maximal portion Bytes */
  267.         if(fileexist(actualfilename) && !force)
  268.         {
  269.             if(!quiet) PrintError(FILE_EXISTS);
  270.             exit(RETURN_WARN);
  271.         }
  272.         Outfp = fopen(actualfilename, "w");
  273.         charno = 0;
  274.         while(portion != charno++)
  275.         {
  276.             if(EOF == (zeichen = getc(Infp))) break;
  277.             putc(zeichen, Outfp);
  278.         }
  279.         fclose(Outfp);
  280.         free(actualfilename);
  281. /* ---------------------------------------------------- */
  282.  
  283.     printf("%i Bytes\n", charno-1);
  284.  
  285.         filenr++;
  286.         if(filenr == number+from) ready = TRUE;
  287.     }
  288.     while(!ready);
  289.     
  290.     printf("\n");
  291.     free(basename);
  292.  
  293.     return(RETURN_OK);
  294. }
  295.  
  296.  
  297.  
  298. /* Funktionen -------------------------------------------------------------------------- */
  299.  
  300. char * MakeFileName(int number)
  301. /*fs*/
  302. {
  303.     char * str;
  304.   char * frontpart;
  305.   char * rearpart;
  306.   int    WCpos = 0;
  307.     int    nrlen = 1;
  308.     int    baselen = 0;
  309.     int    dummy = 0;
  310.     int    step = 0;
  311.  
  312.     dummy = number;
  313.     while(dummy > 9)
  314.     {
  315.         dummy /=10;
  316.         nrlen++;
  317.     }
  318.  
  319.     baselen = strlen(basename);
  320.  
  321.     /* WildCard finden, Stelle in WCpos */
  322.     for(WCpos = 0; WCpos <=baselen; WCpos++)
  323.     {
  324.         if(wildcard[0] == basename[WCpos]) break;
  325.     }
  326.  
  327.     frontpart = (char *) malloc(WCpos + 1);
  328.     if(NULL == frontpart)
  329.     {
  330.       printf("\n  MJoin V1.1 by Harald Löffler\n\n");
  331.         PrintError(NO_MEMORY);
  332.         exit(RETURN_FAIL);
  333.     }
  334.  
  335.     rearpart = (char *) malloc(baselen - WCpos);
  336.     if(NULL == rearpart)
  337.     {
  338.       printf("\n  MJoin V1.1 by Harald Löffler\n\n");
  339.         PrintError(NO_MEMORY);
  340.         exit(RETURN_FAIL);
  341.     }
  342.  
  343.     if(doublenull && number < 10) nrlen++;
  344.  
  345.     str = (char *)malloc(baselen + nrlen + 1);
  346.     if(NULL == str)
  347.     {
  348.       printf("\n  MJoin V1.1 by Harald Löffler\n\n");
  349.         PrintError(NO_MEMORY);
  350.         exit(RETURN_FAIL);
  351.     }
  352.  
  353.     /* frontpart kopieren */
  354.     for(step = 0; step < WCpos; step++)
  355.     {
  356.         frontpart[step] = basename[step];
  357.     }
  358.   frontpart[WCpos] = NULL;
  359.     
  360.     /* rearpart kopieren */
  361.     for(step = WCpos+1; step < baselen; step++)
  362.     {
  363.         rearpart[step-WCpos-1] = basename[step];
  364.     }
  365.   rearpart[baselen-WCpos-1] = NULL;    
  366.  
  367.     if(doublenull && number < 10)
  368.     {
  369.         sprintf(str, "%s0%i%s", frontpart, number, rearpart);
  370.     }
  371.     else
  372.     {
  373.         sprintf(str, "%s%i%s", frontpart, number, rearpart);
  374.     }
  375.   free(rearpart);
  376.   free(frontpart);
  377.     return(str);
  378. }
  379. /*fe*/
  380.  
  381. BOOL fileexist(char * file)
  382. /*fs*/
  383. {
  384.     FILE * fp = NULL;
  385.     BOOL   ret = FALSE;
  386.  
  387.     fp = fopen(file,"r");
  388.  
  389.     if(NULL == fp)
  390.     {
  391.         ret = FALSE;
  392.     }
  393.     else
  394.     {
  395.         ret = TRUE;
  396.     }
  397.  
  398.     if(fp) fclose(fp);
  399.     return(ret);
  400. }
  401. /*fe*/
  402.  
  403. char * Uppercase(char * str)
  404. /*fs*/
  405. {
  406.     int i = -1;
  407.     while(str[++i] != NULL) str[i] = toupper(str[i]);
  408.     return(str);
  409. }
  410. /*fe*/
  411.  
  412. void WrongArgs(char * progname)
  413. /*fs*/
  414. {
  415.     printf("\nUSAGE: %s <filename> [FROM start] [INTO <basename>] [SIZE s] [PARTS n]\n\t\t\t [NULL|QUIET|FORCE]\n\n", progname);
  416.     exit(RETURN_WARN);
  417. }
  418. /*fe*/
  419.  
  420. void PrintError(int error)
  421. /*fs*/
  422. {
  423.     if(error <= PARSE_ERROR && !quiet)
  424.       printf("\n  MSplit V1.1 by Harald Löffler\n");
  425.     if(!(error > PARSE_ERROR && quiet))
  426.     {
  427.         switch(error)
  428.         {
  429.             case MISSING_FILENAME:
  430.                 printf("\n  I need at least a basename!\n");
  431.                 break;
  432.             case SIZE_NOT_LEGAL:
  433.                 printf("\n  SIZE-Value is not a legal number.\n");            
  434.                 break;
  435.             case NUMBER_NOT_LEGAL:
  436.                 printf("\n  NUMBER-Value is not a legal number.\n");
  437.                 break;
  438.             case WRONG_PARAMETERS:
  439.                 printf("\n  One or more wrong Parameter(s)!\n");
  440.                 break;
  441.             case MISSING_WILDCARD:
  442.                 printf("\n  Where is the wildcard? :-|\n");
  443.                 break;
  444.             case FROM_NOT_LEGAL:
  445.                 printf("\n  FROM-Value is not a legal number.\n");            
  446.                 break;
  447.             case FROM_TOO_LOW:
  448.                 printf("\n  FROM-Value must be greater then zero.\n");
  449.                 break;
  450. /* ----------------------------------- PARSE-Errors end ----------------------------------- */
  451.             case MISSING_FILE:
  452.                 printf("  Your file does not exist :-o\n\n");
  453.                 break;
  454.             case FILE_EXISTS:
  455.                 printf("  This Basename allready exists. Use FORCE to overwrite.\n\n");
  456.                 break;
  457.             case CANNOT_OPEN_FILE:
  458.                 printf("  Can´t open file.\n\n");
  459.                 break;
  460.             case NO_MEMORY:
  461.               printf("  Cannot allocate new memory. Abort.\n\n");
  462.               break;
  463.         }
  464.     }
  465. }
  466. /*fe*/
  467.